home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / M2Crypto / SSL / Connection.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  13.9 KB  |  361 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import socket
  5. from Cipher import Cipher, Cipher_Stack
  6. from Session import Session
  7. from M2Crypto import BIO, X509, m2
  8. import timeout
  9. import Checker
  10. from M2Crypto.SSL import SSLError
  11.  
  12. def _serverPostConnectionCheck(*args, **kw):
  13.     return 1
  14.  
  15.  
  16. class Connection:
  17.     clientPostConnectionCheck = Checker.Checker()
  18.     serverPostConnectionCheck = _serverPostConnectionCheck
  19.     m2_bio_free = m2.bio_free
  20.     m2_ssl_free = m2.ssl_free
  21.     
  22.     def __init__(self, ctx, sock = None):
  23.         self.ctx = ctx
  24.         self.ssl = m2.ssl_new(self.ctx.ctx)
  25.         if sock is not None:
  26.             self.socket = sock
  27.         else:
  28.             self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  29.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  30.         self._fileno = self.socket.fileno()
  31.         self.blocking = self.socket.gettimeout()
  32.         self.ssl_close_flag = m2.bio_noclose
  33.  
  34.     
  35.     def __del__(self):
  36.         if getattr(self, 'sslbio', None):
  37.             self.m2_bio_free(self.sslbio)
  38.         
  39.         if getattr(self, 'sockbio', None):
  40.             self.m2_bio_free(self.sockbio)
  41.         
  42.         if self.ssl_close_flag == m2.bio_noclose and getattr(self, 'ssl', None):
  43.             self.m2_ssl_free(self.ssl)
  44.         
  45.         self.socket.close()
  46.  
  47.     
  48.     def close(self):
  49.         m2.ssl_shutdown(self.ssl)
  50.  
  51.     
  52.     def clear(self):
  53.         return m2.ssl_clear(self.ssl)
  54.  
  55.     
  56.     def set_shutdown(self, mode):
  57.         m2.ssl_set_shutdown1(self.ssl, mode)
  58.  
  59.     
  60.     def get_shutdown(self):
  61.         return m2.ssl_get_shutdown(self.ssl)
  62.  
  63.     
  64.     def bind(self, addr):
  65.         self.socket.bind(addr)
  66.  
  67.     
  68.     def listen(self, qlen = 5):
  69.         self.socket.listen(qlen)
  70.  
  71.     
  72.     def ssl_get_error(self, ret):
  73.         return m2.ssl_get_error(self.ssl, ret)
  74.  
  75.     
  76.     def set_bio(self, readbio, writebio):
  77.         m2.ssl_set_bio(self.ssl, readbio._ptr(), writebio._ptr())
  78.  
  79.     
  80.     def set_client_CA_list_from_file(self, cafile):
  81.         m2.ssl_set_client_CA_list_from_file(self.ssl, cafile)
  82.  
  83.     
  84.     def set_client_CA_list_from_context(self):
  85.         m2.ssl_set_client_CA_list_from_context(self.ssl, self.ctx.ctx)
  86.  
  87.     
  88.     def setup_addr(self, addr):
  89.         self.addr = addr
  90.  
  91.     
  92.     def set_ssl_close_flag(self, flag):
  93.         if flag not in (m2.bio_close, m2.bio_noclose):
  94.             raise ValueError('flag must be m2.bio_close or m2.bio_noclose')
  95.         
  96.         self.ssl_close_flag = flag
  97.  
  98.     
  99.     def setup_ssl(self):
  100.         self.sockbio = m2.bio_new_socket(self.socket.fileno(), 0)
  101.         m2.ssl_set_bio(self.ssl, self.sockbio, self.sockbio)
  102.         self.sslbio = m2.bio_new(m2.bio_f_ssl())
  103.         m2.bio_set_ssl(self.sslbio, self.ssl, m2.bio_noclose)
  104.  
  105.     
  106.     def _setup_ssl(self, addr):
  107.         self.setup_addr(addr)
  108.         self.setup_ssl()
  109.  
  110.     
  111.     def set_accept_state(self):
  112.         m2.ssl_set_accept_state(self.ssl)
  113.  
  114.     
  115.     def accept_ssl(self):
  116.         return m2.ssl_accept(self.ssl)
  117.  
  118.     
  119.     def accept(self):
  120.         (sock, addr) = self.socket.accept()
  121.         ssl = Connection(self.ctx, sock)
  122.         ssl.addr = addr
  123.         ssl.setup_ssl()
  124.         ssl.set_accept_state()
  125.         ssl.accept_ssl()
  126.         check = getattr(self, 'postConnectionCheck', self.serverPostConnectionCheck)
  127.         if check is not None:
  128.             if not check(self.get_peer_cert(), ssl.addr[0]):
  129.                 raise Checker.SSLVerificationError, 'post connection check failed'
  130.             
  131.         
  132.         return (ssl, addr)
  133.  
  134.     
  135.     def set_connect_state(self):
  136.         m2.ssl_set_connect_state(self.ssl)
  137.  
  138.     
  139.     def connect_ssl(self):
  140.         return m2.ssl_connect(self.ssl)
  141.  
  142.     
  143.     def connect(self, addr):
  144.         self.socket.connect(addr)
  145.         self.addr = addr
  146.         self.setup_ssl()
  147.         self.set_connect_state()
  148.         ret = self.connect_ssl()
  149.         check = getattr(self, 'postConnectionCheck', self.clientPostConnectionCheck)
  150.         if check is not None:
  151.             if not check(self.get_peer_cert(), self.addr[0]):
  152.                 raise Checker.SSLVerificationError, 'post connection check failed'
  153.             
  154.         
  155.         return ret
  156.  
  157.     
  158.     def shutdown(self, how):
  159.         m2.ssl_set_shutdown(self.ssl, how)
  160.  
  161.     
  162.     def renegotiate(self):
  163.         return m2.ssl_renegotiate(self.ssl)
  164.  
  165.     
  166.     def pending(self):
  167.         return m2.ssl_pending(self.ssl)
  168.  
  169.     
  170.     def _write_bio(self, data):
  171.         return m2.ssl_write(self.ssl, data)
  172.  
  173.     
  174.     def _write_nbio(self, data):
  175.         return m2.ssl_write_nbio(self.ssl, data)
  176.  
  177.     
  178.     def _read_bio(self, size = 1024):
  179.         if size <= 0:
  180.             raise ValueError, 'size <= 0'
  181.         
  182.         return m2.ssl_read(self.ssl, size)
  183.  
  184.     
  185.     def _read_nbio(self, size = 1024):
  186.         if size <= 0:
  187.             raise ValueError, 'size <= 0'
  188.         
  189.         return m2.ssl_read_nbio(self.ssl, size)
  190.  
  191.     
  192.     def write(self, data):
  193.         if self.blocking:
  194.             return self._write_bio(data)
  195.         
  196.         return self._write_nbio(data)
  197.  
  198.     sendall = send = write
  199.     
  200.     def read(self, size = 1024):
  201.         if self.blocking:
  202.             return self._read_bio(size)
  203.         
  204.         return self._read_nbio(size)
  205.  
  206.     recv = read
  207.     
  208.     def setblocking(self, mode):
  209.         self.socket.setblocking(mode)
  210.         self.blocking = mode
  211.  
  212.     
  213.     def fileno(self):
  214.         return self.socket.fileno()
  215.  
  216.     
  217.     def getsockopt(self, *args):
  218.         return apply(self.socket.getsockopt, args)
  219.  
  220.     
  221.     def setsockopt(self, *args):
  222.         return apply(self.socket.setsockopt, args)
  223.  
  224.     
  225.     def get_context(self):
  226.         return m2.ssl_get_ssl_ctx(self.ssl)
  227.  
  228.     
  229.     def get_state(self):
  230.         return m2.ssl_get_state(self.ssl)
  231.  
  232.     
  233.     def verify_ok(self):
  234.         return m2.ssl_get_verify_result(self.ssl) == m2.X509_V_OK
  235.  
  236.     
  237.     def get_verify_mode(self):
  238.         return m2.ssl_get_verify_mode(self.ssl)
  239.  
  240.     
  241.     def get_verify_depth(self):
  242.         return m2.ssl_get_verify_depth(self.ssl)
  243.  
  244.     
  245.     def get_verify_result(self):
  246.         return m2.ssl_get_verify_result(self.ssl)
  247.  
  248.     
  249.     def get_peer_cert(self):
  250.         c = m2.ssl_get_peer_cert(self.ssl)
  251.         if c is None:
  252.             return None
  253.         
  254.         return X509.X509(c, 1)
  255.  
  256.     
  257.     def get_peer_cert_chain(self):
  258.         c = m2.ssl_get_peer_cert_chain(self.ssl)
  259.         if c is None:
  260.             return None
  261.         
  262.         return X509.X509_Stack(c)
  263.  
  264.     
  265.     def get_cipher(self):
  266.         c = m2.ssl_get_current_cipher(self.ssl)
  267.         if c is None:
  268.             return None
  269.         
  270.         return Cipher(c)
  271.  
  272.     
  273.     def get_ciphers(self):
  274.         c = m2.ssl_get_ciphers(self.ssl)
  275.         if c is None:
  276.             return None
  277.         
  278.         return Cipher_Stack(c)
  279.  
  280.     
  281.     def get_cipher_list(self, idx = 0):
  282.         return m2.ssl_get_cipher_list(self.ssl, idx)
  283.  
  284.     
  285.     def set_cipher_list(self, cipher_list):
  286.         return m2.ssl_set_cipher_list(self.ssl, cipher_list)
  287.  
  288.     
  289.     def makefile(self, mode = 'rb', bufsize = 'ignored'):
  290.         if not 'r' in mode:
  291.             pass
  292.         r = '+' in mode
  293.         if not 'w' in mode and 'a' in mode:
  294.             pass
  295.         w = '+' in mode
  296.         b = 'b' in mode
  297.         m2mode = [
  298.             '',
  299.             'r'][r] + [
  300.             '',
  301.             'w'][w] + [
  302.             '',
  303.             'b'][b]
  304.         bio = BIO.BIO(self.sslbio, _close_cb = self.close)
  305.         m2.bio_do_handshake(bio._ptr())
  306.         return BIO.IOBuffer(bio, m2mode, _pyfree = 0)
  307.  
  308.     
  309.     def getsockname(self):
  310.         return self.socket.getsockname()
  311.  
  312.     
  313.     def getpeername(self):
  314.         return self.socket.getpeername()
  315.  
  316.     
  317.     def set_session_id_ctx(self, id):
  318.         ret = m2.ssl_set_session_id_context(self.ssl, id)
  319.         if not ret:
  320.             raise SSLError(m2.err_reason_error_string(m2.err_get_error()))
  321.         
  322.  
  323.     
  324.     def get_session(self):
  325.         sess = m2.ssl_get_session(self.ssl)
  326.         return Session(sess)
  327.  
  328.     
  329.     def set_session(self, session):
  330.         m2.ssl_set_session(self.ssl, session._ptr())
  331.  
  332.     
  333.     def get_default_session_timeout(self):
  334.         return m2.ssl_get_default_session_timeout(self.ssl)
  335.  
  336.     
  337.     def get_socket_read_timeout(self):
  338.         return timeout.struct_to_timeout(self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, 8))
  339.  
  340.     
  341.     def get_socket_write_timeout(self):
  342.         return timeout.struct_to_timeout(self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, 8))
  343.  
  344.     
  345.     def set_socket_read_timeout(self, timeo):
  346.         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, timeo.pack())
  347.  
  348.     
  349.     def set_socket_write_timeout(self, timeo):
  350.         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, timeo.pack())
  351.  
  352.     
  353.     def get_version(self):
  354.         return m2.ssl_get_version(self.ssl)
  355.  
  356.     
  357.     def set_post_connection_check_callback(self, postConnectionCheck):
  358.         self.postConnectionCheck = postConnectionCheck
  359.  
  360.  
  361.